# coding=utf-8
# Create your views here.
#from kinor_base.models import Sale
from django.core.exceptions import ValidationError
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.http import HttpResponseRedirect, HttpResponseNotFound
from django.db import connection, transaction
import itertools
import models
import datetime
from django import forms
from helper import select, selectDict,selectOne, withLoggedUser,commit, render, handleAddForm, HiddenField, handleForm, withLoggedAdmin, handleRemove, handleGenericShow, getUser, getUserId, handleShow


def graneFilmy(request):
    query = 'SELECT id, tytul FROM grany_film'
    fields = ('id', 'tytul')
    vals = ()
    user_id = getUserId(request)
    if user_id:
        query = 'SELECT id, tytul, exists(SELECT * FROM KinoRezerwacja_Seans AS s JOIN KinoRezerwacja_Instancja_miejsca AS im ON (im.id_seansu = s.id) JOIN KinoRezerwacja_rezerwacja AS r ON (r.id_instancji_miejsca = im.id) WHERE r.id_klienta = %s AND grany_film.id = s.id_filmu) AS obejzany FROM grany_film ORDER BY  tytul'
        fields += ('objezany',)
        vals = (user_id,)
    tmp = select(query, vals)
    filmy = []
    for r in tmp:
        fr = {}
        for i in range(len(fields)):
            fr[fields[i]] = r[i]
        filmy.append(fr)
    return render('KinoRezerwacja/index.html', {'filmy':filmy,}, request)


def wyswietlBudynkiSale(request):
    bs = select("SELECT b.id, Adres, s.Opis FROM KinoRezerwacja_Budynek AS b LEFT OUTER JOIN KinoRezerwacja_Sala AS s ON (b.id = s.Id_budynku) ORDER BY b.id")
    budynki = itertools.groupby(bs, lambda x:(x[0],x[1]))
    budynki = [ (b[0][1], [ y for (i,x,y) in b[1] if y ]) for b in budynki ]
    return render('KinoRezerwacja/budynki.html', {'budynki':budynki}, request)

def rozkladWBudynku(request):
    rozklad = select('SELECT id_budynku, adres, opis, id_sali, opis_sali, rozpoczecie, id_filmu, tytul FROM Rozklad WHERE rozpoczecie IS NOT NULL ORDER BY rozpoczecie')
    return render('KinoRezerwacja/rozkladWBudynku.html', {'rozklad':rozklad}, request)

def wyswietlFilm(request, id):
    seanse = selectDict('SELECT {fields} FROM seans_film WHERE id_filmu = %s', ('tytul', 'rezyser', 'aktorzy', 'opis', 'czas_trwania', 'premiera','premiera_w_polsce', 'id_seansu', 'rozpoczecie',), (id,))
    if not seanse:
        return HttpResponseNotFound('Nie znaleziono filmu')
    film = seanse[0]
    if seanse[0]['id_seansu'] is None:
        seanse = []
    return render('KinoRezerwacja/film.html', { 'film':film,
        'seanse':seanse,}, request) 

def wyswietlSeans(request, id):
    seans = selectOne('SELECT {fields} FROM rozklad WHERE id_seansu = %s', ('id_seansu', 'id_filmu', 'tytul', 'opis_filmu', 'czas_trwania', 'opis_sali', 'adres','rozpoczecie'), (id,))
    if not seans:
        return HttpResponseNotFound('Nie znaleziono seansu.')
    return render('KinoRezerwacja/seans.html', {'seans':seans,}, request)

class LoginForm(forms.Form):
    login = forms.Field(required=True, initial='użytkownik', widget=forms.TextInput)
    haslo = forms.CharField(required=True, initial='hasło', widget=forms.PasswordInput)

def login(request, redirect):
    if redirect == '':
        redirect = '/KinoRezerwacja/graneFilmy/'
    failed = False
    form = LoginForm()
    if request.method == 'POST':
        form = LoginForm(request.POST)
        ok = form.is_valid()  
        if ok:
            login = form.cleaned_data['login']
            haslo = form.cleaned_data['haslo']
            user = selectOne('SELECT {fields} FROM KinoRezerwacja_Klient WHERE login = %s AND haslo= %s', ('id',), (login, haslo))
            if not user:
                ok = False
        if ok:
            request.session['userId'] = user['id']
            return HttpResponseRedirect(redirect)
        else:
            failed = True
    return render_to_response('KinoRezerwacja/login.html', {'failed':failed,'form':form,'redirect':redirect, 'noUserMenu':True},context_instance=RequestContext(request))

def logout(request, redirect):
    if redirect == '':
        redirect = '/KinoRezerwacja/graneFilmy/'
    request.session.clear()
    return HttpResponseRedirect(redirect)

@withLoggedUser
def rezerwacjaSeans(request, id):
    seans = selectOne('SELECT {fields} FROM rozklad WHERE id_seansu = %s',('id_filmu', 'tytul', 'opis_filmu', 'czas_trwania', 'opis_sali', 'adres','rozpoczecie'), (id,))
    if not seans:
        return HttpResponseNotFound('Nie znaleziono seansu.')
    bilety = selectDict('SELECT {fields} FROM seans_bilet WHERE id_seansu = %s', ('id_typu_biletu', 'opis'), (id,))
    miejsca = selectDict('SELECT {fields} FROM miejsca WHERE id_seansu = %s', ('id_instancji_miejsca', 'miejsce', 'rzad', 'stan', 'id_klienta', 'id_rezerwacji'), (id,))

    miejsca = [ (r[0],[ a for a in r[1]]) for r in itertools.groupby(miejsca, lambda x:x['rzad']) ]
    user_id = getUserId(request)
    return render('KinoRezerwacja/seans.html', {'seans':seans,'miejsca':miejsca, 'bilety':bilety, 'user_id':user_id}, request)

@withLoggedUser
def rezerwujMiejsce(request, id_instancji, typ_biletu):
    user_id = getUserId(request)
    if not selectOne('SELECT * FROM KinoRezerwacja_Rezerwacja WHERE id_instancji_miejsca = %s AND id_klienta = %s', params=(id_instancji, user_id)):
        commit('INSERT INTO KinoRezerwacja_Rezerwacja (id_klienta, id_instancji_miejsca, id_typu_biletu, kiedy) VALUES (%s, %s, %s, now())',(user_id, id_instancji, typ_biletu))
    seans, = selectOne('SELECT id_seansu FROM KinoRezerwacja_instancja_miejsca WHERE id = %s', params=(id_instancji,))
    return HttpResponseRedirect('/KinoRezerwacja/rezerwacjaSeans/{0}/'.format(seans))

@withLoggedUser
def usunRezerwacje(request, id):
    user_id = getUserId(request)
    rezerwacja = selectOne('SELECT {fields} FROM KinoRezerwacja_Rezerwacja WHERE id = %s AND id_klienta = %s',('id_instancji_miejsca',), params=(id, user_id))
    if rezerwacja:
        seans = selectOne('SELECT {fields} FROM KinoRezerwacja_instancja_miejsca WHERE id = %s', ('id_seansu',), (rezerwacja['id_instancji_miejsca'],))
        commit('DELETE FROM KinoRezerwacja_Rezerwacja WHERE id = %s AND id_klienta = %s', (id, user_id))
        return HttpResponseRedirect('/KinoRezerwacja/rezerwacjaSeans/{0}/'.format(seans['id_seansu']))
    else:
        return HttpResponseNotFound('Nie znaleziono rezerwacji')

def repertuar(request, dzien):
    dzien = int(dzien)
    repertuar = selectDict("SELECT {fields} FROM rozklad WHERE rozpoczecie - now() >= interval '%s days' AND rozpoczecie - now() <  interval '%s days' ORDER BY rozpoczecie", 
            ('id_seansu', 'tytul', 'rozpoczecie', 'id_filmu', 'adres'), (dzien, dzien+1))
    next = dzien+1
    prev = dzien-1 
    return render('KinoRezerwacja/repertuar.html', {'repertuar':repertuar,'next':next,'prev':prev,'prevOk':True}, request)


class DodajFilmForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajFilmForm, self).__init__(*args, **kwargs)
        if 'data' in kwargs:
            self.fields['czas_trwania'].widget.attrs = {'readonly':True}
    tytul = forms.CharField(max_length=200, label="Tytuł")
    rezyser = forms.CharField(max_length=200, label="Reżyser")
    aktorzy = forms.CharField(widget=forms.Textarea, label="Aktorzy")
    opis = forms.CharField(widget=forms.Textarea, label="Opis")
    czas_trwania = forms.IntegerField(min_value=1, label="Czas trwania")
    premiera = forms.DateField(label="Premiera")
    premiera_w_polsce = forms.DateField(label="Premiera w Polsce")
    
@withLoggedAdmin
def dodajFilm(request, updateId=None):
    return handleAddForm(request, DodajFilmForm, 'KinoRezerwacja_Film', ('tytul', 'rezyser', 'aktorzy', 'opis', 'czas_trwania', 'premiera', 'premiera_w_polsce',), ('Dodaj film' if updateId is None else 'Zmień film'), redirect='/KinoRezerwacja/wyswietlFilmy/0/10/', updateId=updateId)

class DodajBudynekForm(forms.Form):
    adres = forms.CharField(max_length=200)
    kontakt = forms.CharField(widget=forms.Textarea)
    opis = forms.CharField(widget=forms.Textarea)

@withLoggedAdmin
def dodajBudynek(request, updateId=None):
    return handleAddForm(request, DodajBudynekForm, 'KinoRezerwacja_Budynek', ('adres', 'kontakt', 'opis',), ('Dodaj budynek' if not updateId else 'Zmień budynek'), updateId=updateId, redirect='/KinoRezerwacja/wyswietlBudynki/0/10/')

class DodajSaleForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajSaleForm,self).__init__(*args, **kwargs)
        self.fields['id_budynku'].choices = select("SELECT id, adres FROM kinorezerwacja_budynek AS b ORDER BY adres") 
    id_budynku = forms.ChoiceField(label='Budynek')
    opis = forms.CharField(max_length=200)
    ile_rzedow = forms.IntegerField(max_value=500, min_value=1)
    ile_miejsc_w_rzedzie = forms.IntegerField(max_value=500, min_value=1)
    czas_przerwy_technicznej = forms.IntegerField(min_value=1)

@withLoggedAdmin
def dodajSale(request):
    return handleAddForm(request, DodajSaleForm, 'KinoRezerwacja_Sala', ('id_budynku', 'opis', 'ile_rzedow', 'ile_miejsc_w_rzedzie', 'czas_przerwy_technicznej'), query='SELECT dodaj_sale(%s, %s, %s, %s, %s)', title='Dodaj salę', redirect='/KinoRezerwacja/wyswietlSale/0/10/')

class DodajSeansForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajSeansForm,self).__init__(*args, **kwargs)
        self.fields['id_filmu'].choices=select("SELECT id, tytul FROM KinoRezerwacja_film ORDER BY tytul")
        self.fields['id_sali'].choices=select("SELECT id, opis FROM KinoRezerwacja_Sala ORDER BY opis")
        self.fields['mozliwe_bilety'].choices=select("SELECT id, opis FROM KinoRezerwacja_Typ_biletu")
    id_filmu = forms.ChoiceField()
    id_sali = forms.ChoiceField()
    rozpoczecie = forms.DateTimeField()
    mozliwe_bilety = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple)

@withLoggedAdmin
def dodajSeans(request):
    def handleOk(form):
        data = form.cleaned_data
        seans_id = commit('SELECT dodaj_seans(%s, %s, %s)', (data['id_filmu'], data['id_sali'], data['rozpoczecie'],), fetch=True)[0]
        for id in data['mozliwe_bilety']:
            commit('INSERT INTO KinoRezerwacja_Mozliwy_bilet (id_typu, id_seansu) VALUES (%s, %s)', (id, seans_id))
        return HttpResponseRedirect('/KinoRezerwacja/wyswietlSeanse/0/10/')
    return handleForm(request, DodajSeansForm,  'Dodaj seans', handleOk)

class DodajAwarieMiejscaForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajAwarieMiejscaForm,self).__init__(*args, **kwargs)
        self.fields['id_obiektu'].choices=select("SELECT m.id, s.opis||' '||rzad||','||miejsce as nazwa FROM KinoRezerwacja_miejsce as m JOIN KinoRezerwacja_sala as s ON (s.id = m.id_sali) ORDER BY nazwa")
    czego = HiddenField(initial='miejsca')
    id_obiektu = forms.ChoiceField()
    od = forms.DateTimeField()
    do = forms.DateTimeField(required=False)

@withLoggedAdmin
def dodajAwarieMiejsca(request):
    return handleAddForm(request, DodajAwarieMiejscaForm, 'KinoRezerwacja_Awaria', title='Dodaj awarię miejsca', escape=True, redirect='/KinoRezerwacja/wyswietlAwarie/0/10/') 

class DodajAwarieSaliForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajAwarieSaliForm,self).__init__(*args, **kwargs)
        self.fields['id_obiektu'].choices=select("SELECT id, opis FROM KinoRezerwacja_sala ORDER BY opis")
    czego = HiddenField(initial='sali')
    id_obiektu = forms.ChoiceField()
    od = forms.DateTimeField()
    do = forms.DateTimeField(required=False)

@withLoggedAdmin
def dodajAwarieSali(request):
    return handleAddForm(request, DodajAwarieSaliForm, 'KinoRezerwacja_Awaria', title='Dodaj awarię sali', escape=True, redirect='/KinoRezerwacja/wyswietlAwarie/0/10/') 


def inFuture(date):
    if datetime.datetime.now() > date:
        raise ValidationError('Data musi być w przyszłości')

class ZmienAwarieForm(forms.Form):
   do = forms.DateTimeField(validators=[inFuture,])


@withLoggedAdmin
def zmienAwarie(request, id):
    awaria = selectOne('SELECT {fields} FROM KinoRezerwacja_Awaria WHERE id = %s',("id", "id_obiektu", "czego", "od", "do"), params=(id,), escape=True)
    if request.method == 'POST':
        print("ZMIEN AWARIE")
        form = ZmienAwarieForm(request.POST)
        if form.is_valid():
            print("ZMIEN AWARIE {0}".format(form.cleaned_data['do']))
            commit('UPDATE KinoRezerwacja_Awaria SET "do"=%s WHERE id=%s AND "do" is null', (form.cleaned_data['do'], id))
            return HttpResponseRedirect('/KinoRezerwacja/wyswietlAwarie/0/10/')
    else:
        form = ZmienAwarieForm()
    return render('KinoRezerwacja/awaria.html', {'form':form, 'title':'Zmień awarię', 'awaria':awaria,}, request, context_instance=RequestContext(request))

class DodajPromocjeForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajPromocjeForm,self).__init__(*args, **kwargs)
        self.fields['id_rangi'].choices = [('-1','-1: Dla wszystkich')]+select("SELECT id, id||': '||skrot FROM KinoRezerwacja_Ranga ORDER BY id")
    od_rezerwacja = forms.DateTimeField()
    do_rezerwacja = forms.DateTimeField(required=False)
    od_seans = forms.DateTimeField()
    do_seans = forms.DateTimeField(required=False)
    id_rangi = forms.ChoiceField(label="Dla kogo")
    znizka = forms.IntegerField()
    typ = forms.ChoiceField(choices=[('procentowa', 'procentowa'), ('stala','stała')])

@withLoggedAdmin
def dodajPromocje(request, updateId=None):
    return handleAddForm(request, DodajPromocjeForm, 'KinoRezerwacja_Promocja', insertFields=('od_rezerwacja', 'do_rezerwacja', 'od_seans', 'do_seans', 'id_rangi', 'znizka', 'typ'), title=('Dodaj promocję' if updateId is None else 'Zmień promocję'), redirect='/KinoRezerwacja/wyswietlPromocje/0/10/', updateId=updateId)

class DodajRangeForm(forms.Form):
    skrot = forms.CharField(max_length=20)
    opis = forms.CharField(max_length=200, widget=forms.Textarea)
    limit_rezerwacji = forms.IntegerField(required=False, min_value=1)

@withLoggedAdmin
def dodajRange(request):
    def handle(form):
        commit('INSERT INTO KinoRezerwacja_Ranga (skrot, opis) VALUES (%s, %s)', (form.cleaned_data['skrot'], form.cleaned_data['opis']))
        limit = form.cleaned_data['limit_rezerwacji']
        if limit:
            id = selectOne('SELECT id FROM KinoRezerwacja_Ranga WHERE skrot=%s', params=(form.cleaned_data['skrot'],))[0]
            commit('INSERT INTO KinoRezerwacja_Limit_rezerwacji (id_rangi, "limit") VALUES (%s, %s)', (id, limit))
        return HttpResponseRedirect('/KinoRezerwacja/wyswietlRangi/0/10/')
    return handleForm(request, DodajRangeForm, 'Dodaj range', handle)

class DodajTypBiletuForm(forms.Form):
    opis = forms.CharField(max_length=100)
    cena = forms.FloatField(min_value=0.01)

@withLoggedAdmin
def dodajTypBiletu(request, updateId=None):
    return handleAddForm(request, DodajTypBiletuForm, 'KinoRezerwacja_Typ_biletu', insertFields=('opis', 'cena'), title=('Dodaj typ biletu' if not updateId else 'Zmień typ biletu'), redirect='/KinoRezerwacja/wyswietlTypyBiletow/0/10/', updateId=updateId)

class DodajKlientaForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajKlientaForm, self).__init__(*args, **kwargs)
        self.fields['rangi'].choices = select("SELECT id, skrot FROM KinoRezerwacja_Ranga")
    login = forms.CharField()
    haslo = forms.CharField()
    imie = forms.CharField()
    nazwisko = forms.CharField()
    rangi = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple)

@withLoggedAdmin
def dodajKlienta(request, updateId=None):
    def dodajRangi(form):
        userId = selectOne('SELECT id FROM KinoRezerwacja_Klient WHERE login = %s', params=(form.cleaned_data['login'],))[0]
        cur = connection.cursor()
        cur.execute('DELETE FROM KinoRezerwacja_ranga_klienta WHERE id_klienta = %s', (userId,))
        for r in form.cleaned_data['rangi']:
            cur.execute('INSERT INTO KinoRezerwacja_ranga_klienta (id_rangi, id_klienta) VALUES (%s, %s)', (r, userId))
        transaction.commit_unless_managed()
    insertFields = ('login', 'haslo', 'imie', 'nazwisko')
    if updateId is None:
        return handleAddForm(request, DodajKlientaForm, 'KinoRezerwacja_klient', insertFields=insertFields, redirect='/KinoRezerwacja/wyswietlKlientow/0/10/', title='Dodaj klienta', query='SELECT dodaj_nowego_klienta(%s, %s, %s, %s)',  additionalFunction=dodajRangi)
    else:
        initial = selectOne('SELECT {fields} FROM KinoRezerwacja_klient WHERE id = %s', insertFields, (updateId,))
        initial['rangi'] = [ r[0] for r in select("SELECT id_rangi FROM KinoRezerwacja_ranga_klienta WHERE id_klienta = %s", params=(updateId,))]
        emptyForm = DodajKlientaForm(initial=initial)
        return handleAddForm(request, DodajKlientaForm, 'KinoRezerwacja_klient', insertFields=insertFields, redirect='/KinoRezerwacja/wyswietlKlientow/0/10/', title='Zmień klienta', updateId=updateId, additionalFunction=dodajRangi, emptyForm=emptyForm)

class DodajRezerwacjeForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajRezerwacjeForm,self).__init__(*args, **kwargs)
        self.fields['id_klienta'].choices=select("SELECT id, imie||' '||nazwisko FROM KinoRezerwacja_klient")
        self.fields['id_instancji_miejsca'].choices=select("SELECT id,id FROM KinoRezerwacja_Instancja_miejsca WHERE stan='wolny'")
        self.fields['id_typu_biletu'].choices=select("SELECT id, opis FROM KinoRezerwacja_Typ_biletu")
    id_klienta = forms.ChoiceField()
    id_instancji_miejsca = forms.ChoiceField()
    id_typu_biletu = forms.ChoiceField()
    kiedy = forms.DateTimeField()

@withLoggedAdmin
def dodajRezerwacje(request):
    return handleAddForm(request, DodajRezerwacjeForm, 'KinoRezerwacja_Rezerwacja', title='Dodaj Rezerwację', redirect='/KinoRezerwacja/wyswietlRezerwacje/0/10/')

class DodajMozliwyBiletForm(forms.Form):
    def __init__(self, *args, **kwargs):
        super(DodajMozliwyBiletForm,self).__init__(*args, **kwargs)
        self.fields['id_typu'].choices=select('SELECT id, opis from KinoRezerwacja_Typ_biletu')
        self.fields['id_seansu'].choices=select("SELECT id_seansu, tytul||', '||rozpoczecie from seans_film")
    id_typu = forms.ChoiceField(label="Typ biletu")
    id_seansu = forms.ChoiceField(label="Seans")

@withLoggedAdmin
def dodajMozliwyBilet(request):
    return handleAddForm(request, DodajMozliwyBiletForm, 'KinoRezerwacja_Mozliwy_bilet', title='Dodaj możliwy bilet', redirect='/KinoRezerwacja/wyswietlMozliweBilety/0/10/')

def validateLogin(login):
    if selectOne('SELECT * FROM KinoRezerwacja_Klient WHERE login = %s', params=(login,)):
        raise ValidationError('Użytkownik o takim loginie już istnieje')

class RejestrujForm(forms.Form):
    login = forms.CharField(validators=[validateLogin])
    haslo = forms.CharField(widget=forms.PasswordInput)
    powtorz_haslo = forms.CharField(widget=forms.PasswordInput)
    imie = forms.CharField()
    nazwisko = forms.CharField()

def rejestruj(request):
    def check(form):
        data =  form.cleaned_data
        if data['haslo'] != data['powtorz_haslo']:
            return False
        return True
    return handleAddForm(request, RejestrujForm, 'KinoRezerwacja_klient', insertFields=('login', 'haslo', 'imie', 'nazwisko'), redirect='/KinoRezerwacja/login/', title='Zarejestruj się', checkFunction=check, errorText="Niepoprawnie wypełniony formularz", query='SELECT dodaj_nowego_klienta(%s, %s, %s, %s)')

@withLoggedAdmin
def wyswietlFilmy(request, begin, limit):
    return handleGenericShow(request, models.Film, begin, limit, dodaj='Film', zmien='Film')

@withLoggedAdmin
def wyswietlSeanse(request, begin, limit):
    return handleGenericShow(request, models.Seans, begin, limit, dodaj='Seans')

@withLoggedAdmin
def wyswietlKlientow(request, begin, limit):
    return handleGenericShow(request, models.Klient, begin, limit, dodaj='Klienta', zmien="Klienta")

@withLoggedAdmin
def wyswietlBudynki(request, begin, limit):
    return handleGenericShow(request, models.Budynek, begin, limit, dodaj='Budynek', zmien='Budynek')

@withLoggedAdmin
def wyswietlRezerwacje(request, begin, limit):
    return handleGenericShow(request, models.Rezerwacja, begin, limit, dodaj='Rezerwacje', dodajName='Rezerwację')

@withLoggedAdmin
def wyswietlTypyBiletow(request, begin, limit):
    return handleGenericShow(request, models.Typ_biletu, begin, limit, dodaj='TypBiletu', dodajName='Typ biletu', zmien='TypBiletu')

@withLoggedAdmin
def wyswietlSale(request, begin, limit):
    return handleGenericShow(request, models.Sala, begin, limit, dodaj='Sale', dodajName='Salę')

@withLoggedAdmin
def wyswietlRangi(request, begin, limit):
    return handleShow(request, 'ranga_limit', ('id', 'skrot', 'opis', 'limit_rezerwacji'), usunUrl=None, baseUrl='/KinoRezerwacja/wyswietlRangi', begin=int(begin), limit=int(limit), dodaj=('/KinoRezerwacja/dodajRange/', 'Dodaj rangę'), title='Rangi')

@withLoggedAdmin
def wyswietlPromocje(request, begin, limit):
    return handleGenericShow(request, models.Promocja, begin, limit, dodaj='Promocje', dodajName='Promocję', zmien='Promocje')

@withLoggedAdmin
def wyswietlAwarie(request, begin, limit):
    return handleGenericShow(request, models.Awaria, begin, limit, adminMore=[{'href':'/KinoRezerwacja/dodajAwarieMiejsca/', 'label':'Dodaj awarię miejsca'}, {'href':'/KinoRezerwacja/dodajAwarieSali/', 'label':'Dodaj awarię sali'}], zmien='Awarie')

@withLoggedAdmin
def usunFilm(request, id):
    return handleRemove('KinoRezerwacja_film', id, '/KinoRezerwacja/wyswietlFilmy/') 
@withLoggedAdmin
def usunSeans(request, id):
    return handleRemove('KinoRezerwacja_seans', id, '/KinoRezerwacja/wyswietlSeanse/')

@withLoggedUser
def pokazRezerwacje(request, id, all=True):
    user = getUser(request)
    if not user["admin"]:
        id = user["id"]
    cond = []
    vals = ()
    if id:
        cond.append("id_klienta=%s")
        vals = (id,)
    if not all:
        cond.append("stan = 'zarezerwowany'")
    query = "SELECT {fields} FROM rezerwacja"
    if cond:
        query += " WHERE "+" AND ".join(cond)
    rezerwacje = selectDict(query, ('kiedy', 'id', 'miejsce', 'rzad', 'opis_sali', 'stan', 'tytul', 'rozpoczecie', 'opis_biletu', 'cena', 'cena_promocyjna', 'id_seansu', 'id_filmu', 'id_instancji_miejsca'), vals) 
    cena = sum(r['cena_promocyjna'] for r in rezerwacje if r['stan'] == 'zarezerwowany')
    return render('KinoRezerwacja/rezerwacje.html', {'rezerwacje':rezerwacje, 'title':'Rezerwacje', 'tenUrl':request.path, 'cena':cena}, request)

@withLoggedUser
def mojeRezerwacje(request):
    return pokazRezerwacje(request, getUser(request)['id'])

@withLoggedUser
def rezerwacja(request, id):
    user_id = getUserId(request)
    rezerwacja = selectOne("SELECT {fields} FROM rezerwacja WHERE id = %s AND id_klienta=%s", ('kiedy', 'id', 'miejsce', 'rzad', 'opis_sali', 'stan', 'tytul', 'rozpoczecie', 'opis_biletu', 'cena', 'cena_promocyjna', 'id_seansu', 'id_filmu'), (id,user_id))
    return render('KinoRezerwacja/rezerwacja.html', {'rezerwacja':rezerwacja, 'title':'Rezerwacja {0}'.format(id)}, request)

@withLoggedAdmin
def kupBilet(request, id, redirect):
    commit("UPDATE KinoRezerwacja_Instancja_miejsca SET stan='kupiony' WHERE id = %s", (id,))
    return HttpResponseRedirect(redirect)

class KasaLoginForm(forms.Form):
    login = forms.CharField(required=False)

@withLoggedAdmin
def kasa(request):
    def handleOk(form):
        id = selectOne("SELECT {fields} FROM KinoRezerwacja_Klient WHERE login=%s", ('id',),(form.cleaned_data['login'],))
        if not id:
            del request.session['admin_userId']
            return HttpResponseRedirect('/KinoRezerwacja/kasa/')
        id = id['id']
        request.session['admin_userId'] = id
        return HttpResponseRedirect('/KinoRezerwacja/pokazRezerwacje/{0}/'.format(id))
    return handleForm(request, KasaLoginForm, 'Podaj login klienta', handleOk)

